In some datasharing architectures, workload is spread across several members or computer systems of a datasharing group. While such spreading of the workload increases the scalability and reliability of the database system, it does so at a performance cost. One instance where performance in datasharing systems is greatly affected occurs when applications utilize keys or indexes with high levels of contention. For example, if an index is created on a timestamp column where the current timestamp is being inserted, the result is that all applications will need to access the last page within an index tree in order to perform the index insertion. As a result, this index page becomes a ‘hot spot’ and contention increases. In a datasharing environment, the impacts are even greater when multiple datasharing members have such hot spots, because only a single system can be updating the ‘hot spot’ page at a time. When updating transactions that make changes to the index tree are spread across different members, each member must wait in turn for exclusive access to the page. This typically results in inter-system communication and serialization techniques where an updater has to request exclusive access, and then wait for the exclusive access to the hot spot to be granted. In sustained update environments, this results in hot pages “ping-ponging” back and forth between the members. When a member is able to retain the exclusive access to the page for a small duration to accommodate pending update operations, such as by holding an exclusive lock for the page, this may result in a member that does not currently have exclusive access to wait for access, sometimes for a significant amount of time. If there are many members in the datasharing group, other members could obtain exclusive access to the page first, so the waits can be even longer.